home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dcpp / subs.c < prev    next >
C/C++ Source or Header  |  1997-09-09  |  5KB  |  305 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6.  
  7. /*
  8.  *  SUBS.C
  9.  *
  10.  */
  11.  
  12. #include "defs.h"
  13. #ifdef AMIGA
  14. #include <exec/tasks.h>     /*    for SetRequester() */
  15. #include <dos/dos.h>
  16. #include <dos/dosextens.h>
  17. #endif
  18.  
  19. #ifndef O_BINARY
  20. #define O_BINARY 0
  21. #endif
  22.  
  23. Prototype void cerror(short, ...);
  24. Prototype void *zalloc(long);
  25. Prototype void *AllocCopy(void *, long);
  26. Prototype Include *GetNominalInclude(int);
  27. Prototype void ErrorNoMemory(void);
  28. Prototype void ErrorOpenFailed(char *, short);
  29. Prototype __stkargs int TriGraphConvert(short);
  30. Prototype char *ObtainErrorString(short);
  31. Prototype void ErrorExit(short);
  32.  
  33. Prototype void eprintf(const char *ctl, ...);
  34. Prototype void veprintf(const char *ctl, va_list va);
  35. Prototype void eputc(char c);
  36.  
  37. void *SetRequester(void *);
  38.  
  39. char    *ErrorFileName1 = DCC_CONFIG "dice.errors";
  40. char    *ErrorFileName2 = DCC "config/dice.errors";
  41. char    *ErrorAry;
  42. long    ErrorArySize;
  43. char    ErrBuf[128];
  44.  
  45. void
  46. cerror(short errorId, ...)
  47. {
  48.     static const char *Ary[] = { "?Bad", "Error", "Warning", "Fatal" };
  49.     Include *inc = GetNominalInclude(1);
  50.     va_list va;
  51.  
  52.     if (inc && inc->FileName == NULL)
  53.     inc->FileName = "<unknown-file>";
  54.  
  55.     eprintf("DCPP: \"%s\" L:%d C:0 %.*s:%d ",
  56.     ((inc) ? inc->FileName : ""),
  57.     ((inc) ? inc->LineNo : 0),
  58.     ((ErrorOpt == 2) ? 1 : (int)strlen(Ary[errorId >> 12])),
  59.     Ary[errorId >> 12],
  60.     errorId & 0x0FFF
  61.     );
  62.     va_start(va, errorId);
  63.     veprintf(ObtainErrorString(errorId & 0x0FFF), va);
  64.     va_end(va);
  65.     eputc('\n');
  66.  
  67.     switch(errorId & EF_MASK) {
  68.     case EF_WARN:
  69.     if (ExitCode < 5)
  70.         ExitCode = 5;
  71.     break;
  72.     case EF_ERROR:
  73.     if (ExitCode < 20)
  74.         ExitCode = 20;
  75.     break;
  76.     case EF_FATAL:
  77.     ErrorExit(20);
  78.     break;
  79.     }
  80. }
  81.  
  82. void
  83. ErrorExit(short code)
  84. {
  85.     if (Fo)
  86.     fclose(Fo);
  87.     if (OutName)
  88.     remove(OutName);
  89.     if (ExitCode < code)
  90.     ExitCode = code;
  91.     exit(ExitCode);
  92. }
  93.  
  94. void *
  95. zalloc(bytes)
  96. long bytes;
  97. {
  98.     static char *Buf;
  99.     static long Bytes;
  100.     void *ptr;
  101.  
  102.     bytes = (bytes + 3) & ~3;
  103.  
  104.     if (bytes > Bytes) {
  105.     if (bytes > ZA_SIZE)
  106.         cerror(EFATAL_SOFTWARE_ERROR_ALLOCATE, bytes);
  107.     Buf = malloc(ZA_SIZE);
  108.     if (Buf == NULL)
  109.         ErrorNoMemory();
  110.     Bytes = ZA_SIZE;
  111.     setmem(Buf, Bytes, 0);
  112.     }
  113.     ptr = Buf;
  114.     Buf += bytes;
  115.     Bytes -= bytes;
  116.     return(ptr);
  117. }
  118.  
  119. void *
  120. AllocCopy(buf, bytes)
  121. void *buf;
  122. long bytes;
  123. {
  124.     void *ptr;
  125.  
  126.     if (bytes > 128) {        /*  efficiency    */
  127.     ptr = malloc(bytes);
  128.     if (ptr == NULL)
  129.         ErrorNoMemory();
  130.     } else {
  131.     ptr = zalloc(bytes);
  132.     }
  133.     movmem(buf, ptr, bytes);
  134.     return(ptr);
  135. }
  136.  
  137. Include *
  138. GetNominalInclude(int noerr)
  139. {
  140.     Include *inc = PushBase;
  141.  
  142.     while (inc && inc->IsFile == 0)
  143.     inc = inc->Next;
  144.     if (inc == NULL) {
  145.     if (noerr)
  146.         return(NULL);
  147.     cerror(EFATAL_NOMINAL_INCLUDE);
  148.     }
  149.     return(inc);
  150. }
  151.  
  152. void
  153. ErrorNoMemory()
  154. {
  155.     eprintf("NO MEMORY!\n");
  156.     ErrorExit(25);
  157. }
  158.  
  159. void
  160. eprintf(const char *ctl, ...)
  161. {
  162.     va_list va;
  163.  
  164.     va_start(va, ctl);
  165.     veprintf(ctl, va);
  166.     va_end(va);
  167. }
  168.  
  169. void
  170. veprintf(const char *ctl, va_list va)
  171. {
  172.     vfprintf(stderr, ctl, va);
  173.     if (ErrorFi)
  174.         vfprintf(ErrorFi, ctl, va);
  175. }
  176.  
  177. void
  178. eputc(char c)
  179. {
  180.     fputc(c, stderr);
  181.     if (ErrorFi)
  182.         fputc(c, ErrorFi);
  183. }
  184.  
  185. void
  186. ErrorOpenFailed(char *file, short len)
  187. {
  188.     if (len == 0)
  189.     len = strlen(file);
  190.     cerror(EERROR_CANT_OPEN_FILE, len, file);
  191. }
  192.  
  193. __stkargs int
  194. TriGraphConvert(short c)
  195. {
  196.     switch(c) {
  197.     case '=':
  198.     return('#');
  199.     case '(':
  200.     return('[');
  201.     case '/':
  202.     return('\\');
  203.     case ')':
  204.     return(']');
  205.     case '\'':
  206.     return('^');
  207.     case '<':
  208.     return('{');
  209.     case '!':
  210.     return('|');
  211.     case '>':
  212.     return('}');
  213.     case '-':
  214.     return('~');
  215.     }
  216.     return(0);
  217. }
  218.  
  219. char *
  220. ObtainErrorString(short errNum)
  221. {
  222.     short i;
  223.     static char *UseFileName;
  224.  
  225.     if (ErrorAry == NULL) {
  226.     int fd;
  227.     short siz;
  228.     void *save;
  229.  
  230.     save = SetRequester((void *)-1);
  231.     UseFileName = ErrorFileName1;
  232.     fd = open(ErrorFileName1, O_RDONLY|O_BINARY);
  233.     SetRequester(save);
  234.     if (fd < 0) {
  235.         if ((fd = open(ErrorFileName2, O_RDONLY|O_BINARY)) < 0) {
  236.         sprintf(ErrBuf, "(can't open %s!)", ErrorFileName2);
  237.         return(ErrBuf);
  238.         }
  239.         UseFileName = ErrorFileName2;
  240.     }
  241.     siz = lseek(fd, 0L, 2);
  242.     lseek(fd, 0L, 0);
  243.     ErrorAry = malloc(siz + 1);
  244.     read(fd, ErrorAry, siz);
  245.     close(fd);
  246.     {
  247.         char *ptr;
  248.         for (ptr = strchr(ErrorAry, '\n'); ptr; ptr = strchr(ptr + 1, '\n'))
  249.         *ptr = 0;
  250.     }
  251.     ErrorAry[siz] = 0;
  252.     ErrorArySize = siz;
  253.     }
  254.     for (i = 0; i < ErrorArySize; i += strlen(ErrorAry + i) + 1) {
  255.     char *ptr;
  256.     if (ErrorAry[i] == 'C' && ErrorAry[i+1] == 'P' && strtol(ErrorAry + i + 3, &ptr, 10) == errNum)
  257.         return(ptr + 1);
  258.     }
  259.     sprintf(ErrBuf, "(no entry in %s for error)", (UseFileName) ? UseFileName : "??");
  260.     return(ErrBuf);
  261. }
  262.  
  263. #ifdef LATTICE
  264.  
  265. int
  266. cmpmem(ubyte *s1, ubyte *s2, long n)
  267. {
  268.     while (n) {
  269.     if (*s1 < *s2)
  270.         return(-1);
  271.     if (*s1 > *s2)
  272.         return(1);
  273.     --n;
  274.     ++s1;
  275.     ++s2;
  276.     }
  277.     return(0);
  278. }
  279.  
  280. #endif
  281.  
  282. #ifdef AMIGA
  283.  
  284. void *
  285. SetRequester(void *new)
  286. {
  287.     void *old;
  288.     struct Process *proc = (struct Process *)FindTask(NULL);
  289.  
  290.     old = proc->pr_WindowPtr;
  291.     proc->pr_WindowPtr = new;
  292.     return(old);
  293. }
  294.  
  295. #else
  296.  
  297. void *
  298. SetRequester(void *new)
  299. {
  300.     return(NULL);
  301. }
  302.  
  303. #endif
  304.  
  305.